<?php

class myLib
{


 //metodo para leer el array list
 function xml2array($contents, $get_attributes=1, $priority = 'tag') {
    if(!$contents) return array();

    if(!function_exists('xml_parser_create')) {
        //print "'xml_parser_create()' function not found!";
        return array();
    }

    //Get the XML parser of PHP - PHP must have this module for the parser to work
    $parser = xml_parser_create('');
    xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, "UTF-8"); # http://minutillo.com/steve/weblog/2004/6/17/php-xml-and-character-encodings-a-tale-of-sadness-rage-and-data-loss
    xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
    xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
    xml_parse_into_struct($parser, trim($contents), $xml_values);
    xml_parser_free($parser);

    if(!$xml_values) return;//Hmm...

    //Initializations
    $xml_array = array();
    $parents = array();
    $opened_tags = array();
    $arr = array();

    $current = &$xml_array; //Refference

    //Go through the tags.
    $repeated_tag_index = array();//Multiple tags with same name will be turned into an array
    foreach($xml_values as $data) {
        unset($attributes,$value);//Remove existing values, or there will be trouble

        //This command will extract these variables into the foreach scope
        // tag(string), type(string), level(int), attributes(array).
        extract($data);//We could use the array by itself, but this cooler.

        $result = array();
        $attributes_data = array();

        if(isset($value)) {
            if($priority == 'tag') $result = $value;
            else $result['value'] = $value; //Put the value in a assoc array if we are in the 'Attribute' mode
        }

        //Set the attributes too.
        if(isset($attributes) and $get_attributes) {
            foreach($attributes as $attr => $val) {
                if($priority == 'tag') $attributes_data[$attr] = $val;
                else $result['attr'][$attr] = $val; //Set all the attributes in a array called 'attr'
            }
        }

        //See tag status and do the needed.
        if($type == "open") {//The starting of the tag '<tag>'
            $parent[$level-1] = &$current;
            if(!is_array($current) or (!in_array($tag, array_keys($current)))) { //Insert New tag
                $current[$tag] = $result;
                if($attributes_data) $current[$tag. '_attr'] = $attributes_data;
                $repeated_tag_index[$tag.'_'.$level] = 1;

                $current = &$current[$tag];

            } else { //There was another element with the same tag name

                if(isset($current[$tag][0])) {//If there is a 0th element it is already an array
                    $current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;
                    $repeated_tag_index[$tag.'_'.$level]++;
                } else {//This section will make the value an array if multiple tags with the same name appear together
                    $current[$tag] = array($current[$tag],$result);//This will combine the existing item and the new item together to make an array
                    $repeated_tag_index[$tag.'_'.$level] = 2;

                    if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well
                        $current[$tag]['0_attr'] = $current[$tag.'_attr'];
                        unset($current[$tag.'_attr']);
                    }

                }
                $last_item_index = $repeated_tag_index[$tag.'_'.$level]-1;
                $current = &$current[$tag][$last_item_index];
            }

        } elseif($type == "complete") { //Tags that ends in 1 line '<tag />'
            //See if the key is already taken.
            if(!isset($current[$tag])) { //New Key
                $current[$tag] = $result;
                $repeated_tag_index[$tag.'_'.$level] = 1;
                if($priority == 'tag' and $attributes_data) $current[$tag. '_attr'] = $attributes_data;

            } else { //If taken, put all things inside a list(array)
                if(isset($current[$tag][0]) and is_array($current[$tag])) {//If it is already an array...

                    // ...push the new element into that array.
                    $current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;

                    if($priority == 'tag' and $get_attributes and $attributes_data) {
                        $current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
                    }
                    $repeated_tag_index[$tag.'_'.$level]++;

                } else { //If it is not an array...
                    $current[$tag] = array($current[$tag],$result); //...Make it an array using using the existing value and the new value
                    $repeated_tag_index[$tag.'_'.$level] = 1;
                    if($priority == 'tag' and $get_attributes) {
                        if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well

                            $current[$tag]['0_attr'] = $current[$tag.'_attr'];
                            unset($current[$tag.'_attr']);
                        }

                        if($attributes_data) {
                            $current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
                        }
                    }
                    $repeated_tag_index[$tag.'_'.$level]++; //0 and 1 index is already taken
                }
            }

        } elseif($type == 'close') { //End of tag '</tag>'
            $current = &$parent[$level-1];
        }
    }

    return($xml_array);
}

function getBrowser()
{
    $u_agent = $_SERVER['HTTP_USER_AGENT'];
    $bname = 'Unknown';
    $platform = 'Unknown';
    $version= "";

    //First get the platform?
    if (preg_match('/linux/i', $u_agent)) {
        $platform = 'linux';
    }
    elseif (preg_match('/macintosh|mac os x/i', $u_agent)) {
        $platform = 'mac';
    }
    elseif (preg_match('/windows|win32/i', $u_agent)) {
        $platform = 'windows';
    }

    // Next get the name of the useragent yes seperately and for good reason
    if(preg_match('/MSIE/i',$u_agent) && !preg_match('/Opera/i',$u_agent))
    {
        $bname = 'Internet Explorer';
        $ub = "MSIE";
    }
    elseif(preg_match('/Firefox/i',$u_agent))
    {
        $bname = 'Mozilla Firefox';
        $ub = "Firefox";
    }
    elseif(preg_match('/Chrome/i',$u_agent))
    {
        $bname = 'Google Chrome';
        $ub = "Chrome";
    }
    elseif(preg_match('/Safari/i',$u_agent))
    {
        $bname = 'Apple Safari';
        $ub = "Safari";
    }
    elseif(preg_match('/Opera/i',$u_agent))
    {
        $bname = 'Opera';
        $ub = "Opera";
    }
    elseif(preg_match('/Netscape/i',$u_agent))
    {
        $bname = 'Netscape';
        $ub = "Netscape";
    }

    // finally get the correct version number
    $known = array('Version', $ub, 'other');
    $pattern = '#(?<browser>' . join('|', $known) .
    ')[/ ]+(?<version>[0-9.|a-zA-Z.]*)#';
    if (!preg_match_all($pattern, $u_agent, $matches)) {
        // we have no matching number just continue
    }

    // see how many we have
    $i = count($matches['browser']);
    if ($i != 1) {
        //we will have two since we are not using 'other' argument yet
        //see if version is before or after the name
        if (strripos($u_agent,"Version") < strripos($u_agent,$ub)){
            $version= $matches['version'][0];
        }
        else {
            $version= $matches['version'][1];
        }
    }
    else {
        $version= $matches['version'][0];
    }

    // check if we have a number
    if ($version==null || $version=="") {$version="?";}

    return array(
        'userAgent' => $u_agent,
        'name'      => $bname,
        'ub'      => $ub,
        'version'   => $version,
        'platform'  => $platform,
        'pattern'    => $pattern
    );
}


/*
  Metodo que devuelve true o false segun corresponda
 -verifica si el codigo enviado es igual a algun token de seguridad
 */
public function executeToken($palabra_md5)
{
  $codigo= "esferadigital";
  $codigo = md5($codigo);
  if($codigo==$palabra_md5){
      return true;
  }else{
      return false;
  }
}
/*
  Metodo que devuelve true o false segun corresponda
 -verifica si la plataforma existe
 */
public function executeVerificarPlataforma($id)
{
      return true;
}

/*
   Este metodo devuelve true o false
   si encuentra un un email igual en la bd
*/
public function executeVerificar($email)
{
    $email = strtolower(trim($email));
    $email = '%'.$email.'%';
    $criterio = new Criteria();
    $criterio->add(UsuarioPeer::EMAIL, $email,Criteria::LIKE);
    //verificado si la hay resultados para mi busqueda
    if(UsuarioPeer::doCount($criterio)>0){
        return false;
    }else{
        return  true;
    }
}

public function executeVerificar_associate($email)
{
    $email = strtolower(trim($email));
    $email = '%'.$email.'%';
    $criterio = new Criteria();
    $criterio->add(AssociateAccountPeer::ACCOUNTS, $email,Criteria::LIKE);
    //verificado si la hay resultados para mi busqueda
    if(AssociateAccountPeer::doCount($criterio)>0){
        return false;
    }else{
        return  true;
    }
}

public function verificar_por_plataforma($email , $plataforma_key){

    $email = strtolower(trim($email));
    $email = '%'.$email.'%';
    $criterio = new Criteria();
    $criterio->add(UsuarioPeer::EMAIL, $email,Criteria::LIKE);

     if(UsuarioPeer::doCount($criterio)>0){
        /*si usuario existe en pracil vamos a verificar
         si existe en plataforma para ver si lo actualizamos*/
         $user = UsuarioPeer::doSelectOne($criterio);
         if($this->internal_plataforma_array($user->getPlataforma(), $plataforma_key)){
            return  2;
         }else{
            return  3;
         }
        return false;
    }else{/*si no existe en practil
          usuario disponible-Registrar*/
        return  1;
    }

}


public function internal_plataforma_array($array,$plataforma_key){
    /*Formato de array plataforma 1-2-3-5*/
    if($array!=""){
        $lista = explode('-', $array);
            for($i=0 ; $i<count($lista) ; $i++){
                    if($lista[$i]==$plataforma_key){
                        return false;
                    }
            }
            return true;
    }else{
        return true;
    }
}

/*********************************************/

function ObtenerNavegador($user_agent) {
     $navegadores = array(
          'Opera' => 'Opera',
          'Mozilla Firefox'=> '(Firebird)|(Firefox)',
          'Galeon' => 'Galeon',
          'Mozilla'=>'Gecko',
          'MyIE'=>'MyIE',
          'Lynx' => 'Lynx',
          'Netscape' => '(Mozilla/4\.75)|(Netscape6)|(Mozilla/4\.08)|(Mozilla/4\.5)|(Mozilla/4\.6)|(Mozilla/4\.79)',
          'Konqueror'=>'Konqueror',
          'Internet Explorer 7' => '(MSIE 7\.[0-9]+)',
          'Internet Explorer 6' => '(MSIE 6\.[0-9]+)',
          'Internet Explorer 5' => '(MSIE 5\.[0-9]+)',
          'Internet Explorer 4' => '(MSIE 4\.[0-9]+)',
);
foreach($navegadores as $navegador=>$pattern){
       if (preg_match('/'.$pattern.'/', $user_agent))
       return $navegador;
    }
return 'Desconocido';
}


/*************METODOS DE MANUEL**************************/
  /* Servicio que me retorna todos los detalles asociadas a un
   * paquete recibiendo como parametro el codigo del paquete
  */
     public function executeRetorna_caracteristicas_paquetes($id_paquete){
      $vInteger= new sfValidatorInteger(array('required'=>true));

      try {
           $vInteger->clean($id_paquete);
      } catch (sfValidatorError $exc) {
          return null;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(DetallePaqueteCaracteristicaPeer::PAQUETE_ID,$id_paquete);
      $cantidad_encontrada = DetallePaqueteCaracteristicaPeer::doCount($criteria_busqueda) ;

      if($cantidad_encontrada>0){
         $lista_caracteristicas = DetallePaqueteCaracteristicaPeer::doSelect($criteria_busqueda) ;
         return $lista_caracteristicas;
      }else{
         $lista_caracteristicas = null;
         return $lista_caracteristicas;
      }

  }

  /*
   * Retorna cada caracteristica por cada detalle asociado a al paquete
   */
   public function executeRetorna_caracteristicas_detalle_paquetes($id_caracteristicas){
      $vInteger= new sfValidatorInteger(array('required'=>true));

      try {
           $vInteger->clean($id_caracteristicas);
      } catch (sfValidatorError $exc) {
          return null;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(PaqueteCaracteristicaPeer::ID,$id_caracteristicas );
      $cantidad_encontrada = PaqueteCaracteristicaPeer::doCount($criteria_busqueda) ;

      if($cantidad_encontrada>0){
         $lista_caracteristicas = PaqueteCaracteristicaPeer::doSelectOne($criteria_busqueda) ;
         return $lista_caracteristicas;
      }else{
         $lista_caracteristicas = null;
         return $lista_caracteristicas;
      }

  }

/*
 * Verifica si exite el usuario recibiendo como paramtro el codigo
 * del paquete
 * Retorna TRUE si existe
 * Retorna FALSE no existe
 */
  public function executeExiste_usuario($codigo_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($codigo_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(UsuarioPeer::ID,$codigo_id);
       if(UsuarioPeer::doCount($criteria_busqueda)>0){
       return true;
      }else{
          return false;
      }

  }

    /*
   * Servicio que valida la existencia de un paquete recibiendo
   * el codigo del paquete
   * Retorna TRUE si existe
   * Retorna FALSE no existe
   */
    public function executeExiste_paquete($paquete_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($paquete_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(PaquetePeer::ID,$paquete_id);
       if(PaquetePeer::doCount($criteria_busqueda)>0){
       return true;
      }else{
          return false;
      }
  }

    /*
   *Verifico si existe la moneda
   * input ---> id del usuario
   * ouput ---> true(si existe) /  false (no existe)
   */
  public function executeExiste_moneda($tipo_moneda_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($tipo_moneda_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(TipoMonedaPeer::ID,$tipo_moneda_id);
       if(TipoMonedaPeer::doCount($criteria_busqueda)>0){
       return true;
      }else{
          return false;
      }
  }

     public function executeRetorna_moneda($tipo_moneda_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($tipo_moneda_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(TipoMonedaPeer::ID,$tipo_moneda_id);
      $moneda_encontrado = TipoMonedaPeer::doSelectOne($criteria_busqueda) ;

      if(is_object($moneda_encontrado)){
          return $moneda_encontrado;
      }else{
          return null;
      }

  }

   // retorna un objeto Usuario por id
    public function executeRetorna_usuario($usuario_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($usuario_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(UsuarioPeer::ID,$usuario_id);
      $usuario_encontrado = UsuarioPeer::doSelectOne($criteria_busqueda) ;

      if(is_object($usuario_encontrado)){
          return $usuario_encontrado;
      }else{
          return null;
      }
  }

    // retorna un objeto Paquete
    public function executeRetorna_paquete($paquete_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));

      try {
           $vInteger->clean($paquete_id);
      } catch (sfValidatorError $exc) {
          return null;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(PaquetePeer::ID,$paquete_id);
      $paquete_encontrado = PaquetePeer::doSelectOne($criteria_busqueda) ;

      if(is_object($paquete_encontrado)){
          return $paquete_encontrado;
      }else{
          return null;
      }
  }

   // retorna un objeto Paquete por el codigo twocheckout que es unico por cada
  //paquete
    public function executeRetorna_paquete_by_2checkoutId($paquete_id_2checkout){
      $vInteger= new sfValidatorInteger(array('required'=>true));

      try {
           $vInteger->clean($paquete_id_2checkout);
      } catch (sfValidatorError $exc) {
          return null;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(PaquetePeer::CODIGO_TWOCHECKOUT,$paquete_id_2checkout);
      $criteria_busqueda->add(PaquetePeer::FLAGS,"H");
      $paquete_encontrado = PaquetePeer::doSelectOne($criteria_busqueda) ;

      if(is_object($paquete_encontrado)){
          return $paquete_encontrado;
      }else{
          return null;
      }
  }

    // retornar los paquetes comprados segun los id's recibidos de cada
    // usuario
    public function executePaquetes_usuarios($usuario_id, $paquete_id){
      $vInteger= new sfValidatorInteger(array('required'=>true));
      try {
           $vInteger->clean($paquete_id);
           $vInteger->clean($usuario_id);
      } catch (sfValidatorError $exc) {
          return false;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(UsuarioPaquetePeer::PAQUETE_ID,$paquete_id);
      $criteria_busqueda->add(UsuarioPaquetePeer::USUARIO_ID,$usuario_id);

      /*Esta parte queda pendiente por el flags se van a
       manejar de otra manera*/

      $criteria_busqueda->add(UsuarioPaquetePeer::FLAGS,'%H%',Criteria::LIKE);
      $cantidad_paquete_usuario = UsuarioPaquetePeer::doCount($criteria_busqueda);

      if($cantidad_paquete_usuario>0){
          return true;
      }else{
          return false;
      }

  }

/*
 * retorna el usuario por el email
 */
public function executeRetorna_usuario_email($email){
      $vInteger= new sfValidatorEmail(array('required'=>true));
      try {
           $vInteger->clean($email);
      } catch (sfValidatorError $exc) {
          return null;
      }
      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(UsuarioPeer::EMAIL,'%'.$email.'%',Criteria::LIKE);

      $cantidad = UsuarioPeer::doCount($criteria_busqueda) ;

      if($cantidad >0){
              $usuario_encontrado = UsuarioPeer::doSelectOne($criteria_busqueda);
          return $usuario_encontrado;
      }else{
          return null;
      }
  }

public function executeExiste_usuario_plataforma($id_usuario, $id_plataforma){

      $criteria_busqueda = new Criteria();
      $criteria_busqueda->add(UsuarioPeer::ID,$id_usuario);

      $obj_usuario = UsuarioPeer::doSelectOne($criteria_busqueda);

      if(is_object($obj_usuario)){
         return $this->internal_plataforma_array($obj_usuario->getPlataforma(),$id_plataforma);

      }

}



}
